library(SingleCellExperiment)
library(tidyverse)
library(igraph)
library(scran)

devtools::load_all("~/miloR/")

## Setup to use python in Rmd
library(reticulate)
reticulate::use_condaenv("emma_env")

theme_dimred <- function( ... ){
  theme(axis.ticks =element_blank(), axis.text = element_blank(), plot.title = element_text(hjust=0.5), ... )
  }
import scanpy as sc
import pandas as pd
import numpy as np
## To show plots inline
import matplotlib.pyplot as plt
import sys,os
plt.switch_backend('agg')
sys.path.insert(1, '/nfs/team205/ed6/bin/thATAC/preprocess_utils/')
import atac_utils 
import scipy.sparse
from pathlib import Path

# sc._settings.ScanpyConfig.figdir = Path(r.outdir)

Load data

Load anndata object, downloaded from here following the link from Park et al. 2020

rna_adata = sc.read_h5ad("/nfs/team205/ed6/data/Park_scRNAseq/HTA08.v01.A06.Science_human_tcells.raw.h5ad")
rna_adata.X = rna_adata.raw.X
rna_adata.X = scipy.sparse.csc_matrix(rna_adata.X)

Load MOFA projection, to use as reduced dimensionality object

mofa_dims <- read.csv("/nfs/team205/ed6/data/thymus_data/thymus_MOFA_projection.csv") %>%
  column_to_rownames("cell")

## Filter just the scRNA-seq cells and factors 4 knn graoh construciton
mofa_dims <- as.matrix(mofa_dims[rownames(py$rna_adata$obs),1:5])

Convert anndata to SingleCellExperiment object

adata <- py$rna_adata
cnt <- t(adata$X)
rownames(cnt) <- adata$var_names$to_list()
colnames(cnt) <- adata$obs_names$to_list()
logCnt <- log2(cnt + 1)
pca <- prcomp(t(vx))

# Create the SingleCellExperiment object
sce <- SingleCellExperiment(assay=list(counts=cnt, logcounts=logCnt), colData = adata$obs)

reducedDim(sce) <- mofa_dims
reducedDimNames(sce) <- "MOFA"
sce

## Save SingleCellExperiment
saveRDS(sce, "/nfs/team205/ed6/data/Park_scRNAseq/HTA08.v01.A06.Science_human_tcells.SingleCellExperiment.RDS")
sce <- readRDS("~/Downloads/HTA08.v01.A06.Science_human_tcells.SingleCellExperiment.RDS")
sce
class: SingleCellExperiment 
dim: 33694 50514 
metadata(0):
assays(2): counts logcounts
rownames(33694): TSPAN6 TNMD ... RP11-107E5.4 RP11-299P2.2
rowData names(0):
colnames(50514): FCAImmP7179369-AAACCTGAGCCCAATT FCAImmP7179369-AAACCTGAGCCTATGT ...
  Human_colon_16S7985397-TTTGCGCAGAGCCCAA Human_colon_16S7985397-TTTGGTTAGTACGCGA
colData names(14): Sample donor ... cell types umap_density_Age
reducedDimNames(1): MOFA
altExpNames(0):
object.size(sce)
16486280 bytes

Cells in different samples where sorted using different FACS gates, which affect significantly the cell type composition of different samples. To simplify interpretation of DA analysis, I retain only samples that where obtained from total tissue and CD45+ cells, which have a similar cell type composition.

keep_cells <- which(sce$sort %in% c("TOT", "45P"))
sce <- sce[,keep_cells]
sce
class: SingleCellExperiment 
dim: 33694 38081 
metadata(0):
assays(2): counts logcounts
rownames(33694): TSPAN6 TNMD ... RP11-107E5.4 RP11-299P2.2
rowData names(0):
colnames(38081): FCAImmP7179369-AAACCTGAGCCCAATT FCAImmP7179369-AAACCTGAGCCTATGT ...
  Human_colon_16S7985397-TTTGCGCAGAGCCCAA Human_colon_16S7985397-TTTGGTTAGTACGCGA
colData names(14): Sample donor ... cell types umap_density_Age
reducedDimNames(1): MOFA
altExpNames(0):

Make Milo object

milo <- Milo(sce)
milo
class: Milo 
dim: 33694 38081 
metadata(0):
assays(2): counts logcounts
rownames(33694): TSPAN6 TNMD ... RP11-107E5.4 RP11-299P2.2
rowData names(0):
colnames(38081): FCAImmP7179369-AAACCTGAGCCCAATT
  FCAImmP7179369-AAACCTGAGCCTATGT ...
  Human_colon_16S7985397-TTTGCGCAGAGCCCAA
  Human_colon_16S7985397-TTTGGTTAGTACGCGA
colData names(14): Sample donor ... cell types umap_density_Age
reducedDimNames(1): MOFA
altExpNames(0):
neighbourhoods dimensions(1): 0
neighbourhoodCounts dimensions(2): 1 1
neighbourDistances dimensions(2): 1 1
graph names(0):
neighbourhoodIndex names(1): 0
object.size(milo)
13060216 bytes

Build KNN graph

For now I use scran function instead of buildGraph from package because it’s very slow

## Rename MOFA dim reduction as PCA so buildGraph can find it
reducedDim(milo, "PCA") <- reducedDim(milo)
# 
# library(BiocNeighbors)
# library(BiocParallel)
# milo <- buildGraph(milo, k = 30)

knn_graph <- buildKNNGraph(reducedDim(milo, "MOFA"), k=50, d=NA, transposed=TRUE)
miloR::graph(milo) <- knn_graph

Run umap

umap_th <- uwot::umap(reducedDim(milo, "MOFA"), n_neighbors=50 )
reducedDim(milo, 'UMAP') <- umap_th
scater::plotUMAP(milo, colour_by="Age", point_size=0.5, point_alpha=0.5) +
  facet_wrap('colour_by')

Test for differential abundance by age

Use Age as ordinal variable w all ages

knn_graph <- buildKNNGraph(reducedDim(milo, "MOFA"), k=50, d=NA, transposed=TRUE)
miloR::graph(milo) <- knn_graph

Run umap

umap_th <- uwot::umap(reducedDim(milo, "MOFA"), n_neighbors=50, verbose=TRUE)
reducedDim(milo, 'UMAP') <- umap_th
scater::plotUMAP(milo, colour_by="Age", point_size=0.5, point_alpha=0.5) +
  facet_wrap('colour_by')

Sample neighborhoods with refined sampling scheme

# milo@neighbourhoods <- list()
system.time(milo <- makeNeighbourhoods(milo, prop=0.1, k = 50, d=5, refined = TRUE, reduced_dims = "PCA", seed = 43))
Checking valid object
   user  system elapsed 
 62.178   1.181  63.665 
plotNeighborhoodSizeHist(milo, bins=100)

Make model matrix for testing. I use Age as an ordinal variable for testing.

th.model
                  (Intercept) Age
F21_TH_45P                  1   9
F22_TH_TOT                  1   3
F23_TH_45P                  1   5
F29_TH_45P                  1  10
F29_TH_45P_5GEX             1  10
F30_TH_45P                  1   8
F30_TH_45P_5GEX             1   8
F38_TH_45P                  1   7
F38_TH_45P_5GEX             1   7
F41_TH_45P                  1   9
F41_TH_45P_5GEX             1   9
F45_TH_45P                  1   6
F45_TH_45P_5GEX             1   6
F64_TH_TOT_5GEX_1           1   5
F64_TH_TOT_5GEX_2           1   5
C34_TH_TOT_5GEX             1   3
C40_TH_TOT_1                1   1
C40_TH_TOT_2                1   1
C41_TH_TOT_1                1   2
C41_TH_TOT_2                1   2
F74_TH_TOT_5GEX_1           1   4
F74_TH_TOT_5GEX_2           1   4
attr(,"assign")
[1] 0 1
milo <- countCells(milo, 
                   data = data.frame(colData(milo)[,c("Sample","Age")]),
                   samples = "Sample")
Checking data validity
Setting up matrix with 3544 neighbourhoods
Counting cells in neighbourhoods
nh_counts <- milo@neighbourhoodCounts

milo_res <- testNeighbourhoods(milo, design = ~ Age, data = th.meta)
Performing spatial FDR correction
hist(milo_res$PValue)

milo_res %>%
  ggplot(aes(PValue, SpatialFDR)) + geom_point() +
  geom_abline(linetype=2) 


milo_res %>%
  ggplot(aes(SpatialFDR)) + geom_histogram()


milo_res %>%
  mutate(is_sig=ifelse(SpatialFDR < 0.05, TRUE, FALSE)) %>%
  ggplot(aes(logFC, -log10(SpatialFDR), color=is_sig)) +
  geom_point(alpha=0.2)

plotMiloReducedDim(milo, milo_results = milo_res, filter_alpha = NULL)

plotMiloReducedDim(milo, milo_results = milo_res, filter_alpha = 0.1)

Perhaps the most interesting part is that proliferative double positive T cells seem to be divided in 2 groups, those more enriched in early stages and late stages. What are the biological differences between these?

Compare enrichment and pseudotime ordering

---
title: "Milo on human thymus"
output: html_notebook
---

```{r}
library(SingleCellExperiment)
library(tidyverse)
library(igraph)
library(scran)

devtools::load_all("~/miloR/")

## Setup to use python in Rmd
library(reticulate)
reticulate::use_condaenv("emma_env")

theme_dimred <- function( ... ){
  theme(axis.ticks =element_blank(), axis.text = element_blank(), plot.title = element_text(hjust=0.5), ... )
  }
```

```{python, echo=TRUE, eval=FALSE}
import scanpy as sc
import pandas as pd
import numpy as np
## To show plots inline
import matplotlib.pyplot as plt
import sys,os
plt.switch_backend('agg')
sys.path.insert(1, '/nfs/team205/ed6/bin/thATAC/preprocess_utils/')
import atac_utils 
import scipy.sparse
from pathlib import Path

# sc._settings.ScanpyConfig.figdir = Path(r.outdir)
```


### Load data

Load anndata object, downloaded from [here](https://zenodo.org/record/3572422#.XsY2h5NKhQI) following the link from [Park et al. 2020](10.1126/science.aay3224)

```{python, echo=TRUE, eval=FALSE}
rna_adata = sc.read_h5ad("/nfs/team205/ed6/data/Park_scRNAseq/HTA08.v01.A06.Science_human_tcells.raw.h5ad")
rna_adata.X = rna_adata.raw.X
rna_adata.X = scipy.sparse.csc_matrix(rna_adata.X)
```

Load MOFA projection, to use as reduced dimensionality object

```{r, echo=TRUE, eval=FALSE}
mofa_dims <- read.csv("/nfs/team205/ed6/data/thymus_data/thymus_MOFA_projection.csv") %>%
  column_to_rownames("cell")

## Filter just the scRNA-seq cells and factors 4 knn graoh construciton
mofa_dims <- as.matrix(mofa_dims[rownames(py$rna_adata$obs),1:5])
```

Convert `anndata` to `SingleCellExperiment` object 

```{r, echo=TRUE, eval=FALSE}
adata <- py$rna_adata
cnt <- t(adata$X)
rownames(cnt) <- adata$var_names$to_list()
colnames(cnt) <- adata$obs_names$to_list()
logCnt <- log2(cnt + 1)
pca <- prcomp(t(vx))

# Create the SingleCellExperiment object
sce <- SingleCellExperiment(assay=list(counts=cnt, logcounts=logCnt), colData = adata$obs)

reducedDim(sce) <- mofa_dims
reducedDimNames(sce) <- "MOFA"
sce

## Save SingleCellExperiment
saveRDS(sce, "/nfs/team205/ed6/data/Park_scRNAseq/HTA08.v01.A06.Science_human_tcells.SingleCellExperiment.RDS")
```

```{r}
sce <- readRDS("~/Downloads/HTA08.v01.A06.Science_human_tcells.SingleCellExperiment.RDS")
sce
object.size(sce)
```

Cells in different samples where sorted using different FACS gates, which affect significantly the cell type composition of different samples. To simplify interpretation of DA analysis, I retain only samples that where obtained from total tissue and CD45+ cells, which have a similar cell type composition.

```{r}
colData(sce) %>%
  as.data.frame() %>%
  ggplot(aes(Sample, fill=cell.types)) +
  geom_bar(position="fill") +
  coord_flip() +
  facet_grid(sort~., scales="free_y", space="free")
```



```{r}
keep_cells <- which(sce$sort %in% c("TOT", "45P"))
sce <- sce[,keep_cells]
sce
```


Make Milo object
```{r}
milo <- Milo(sce)
milo
object.size(milo)
```

```{r}
test_nh_size <- function(m, prop, k, d=5){
  # m <- m[,sample(colnames(m), size = n_cells)]
  m <- buildGraph(m, k = k, d = d)
  refined_nh <- neighbourhoods(makeNeighbourhoods(m, prop=prop, k=k, d=d, refined = TRUE, seed=42))
  return(sapply(refined_nh, length))
}

reducedDim(milo, "PCA") <- reducedDim(milo)
k_vec <- seq(10,50, by=10)
nh_sizes_th <- lapply(k_vec, function(x) test_nh_size(milo, prop = 0.1, x, d=5))
nh_sizes_th_2 <- lapply(c(60,70,80), function(x) test_nh_size(milo, prop = 0.1, x, d=5))
nh_sizes_th <- set_names(nh_sizes_th, paste0('k', k_vec))
nh_sizes_th_2 <- set_names(nh_sizes_th_2, paste0('k', c(60,70,80)))

imap(c(nh_sizes_th, nh_sizes_th_2), ~ data.frame(nh_size=.x, k=.y)) %>%
  reduce(bind_rows) %>%
  group_by(k) %>%
  mutate(n_neighborhoods=n()) %>%
  ggplot(aes(n_neighborhoods, nh_size, fill=k)) + 
  geom_boxplot(varwidth = TRUE) +
  # geom_histogram(position="identity", alpha=0.6, bins=50) +
  scale_fill_viridis_d()
```

## Build KNN graph

For now I use scran function instead of `buildGraph` from package because it's very slow

```{r}
## Rename MOFA dim reduction as PCA so buildGraph can find it
reducedDim(milo, "PCA") <- reducedDim(milo)
# 
# library(BiocNeighbors)
# library(BiocParallel)
# milo <- buildGraph(milo, k = 30)

knn_graph <- buildKNNGraph(reducedDim(milo, "MOFA"), k=50, d=NA, transposed=TRUE)
miloR::graph(milo) <- knn_graph
```

Run umap
```{r}
umap_th <- uwot::umap(reducedDim(milo, "MOFA"), n_neighbors=50 )
reducedDim(milo, 'UMAP') <- umap_th
```

```{r, fig.width=10, fig.height=10}
scater::plotUMAP(milo, colour_by="Age", point_size=0.5, point_alpha=0.5) +
  facet_wrap('colour_by')
```

## Test for differential abundance by age

<!-- ### Simple case: compare first time point with last one -->

<!-- ```{r} -->
<!-- small_milo <- milo[,which(milo$Age %in% c('7w','17w'))] -->
<!-- ``` -->

<!-- ```{r} -->
<!-- knn_graph <- buildKNNGraph(reducedDim(small_milo, "MOFA"), k=30, d=NA, transposed=TRUE) -->
<!-- miloR::graph(small_milo) <- knn_graph -->
<!-- ``` -->

<!-- Run umap -->
<!-- ```{r} -->
<!-- small_umap_th <- uwot::umap(reducedDim(small_milo, "MOFA"), n_neighbors=30 ) -->
<!-- reducedDim(small_milo, 'UMAP') <- small_umap_th -->
<!-- ``` -->

<!-- ```{r, fig.width=10, fig.height=5} -->
<!-- scater::plotUMAP(small_milo, colour_by="Age", point_size=0.5, point_alpha=0.5) + -->
<!--   facet_wrap('colour_by') -->
<!-- ``` -->

<!-- Sample neighborhoods with refined sampling scheme -->

<!-- ```{r} -->
<!-- # milo@neighbourhoods <- list() -->
<!-- small_milo <- makeNeighbourhoods(small_milo, prop=0.1, k = 30, d=5, refined = TRUE, reduced_dims = "PCA", seed = 100) -->


<!-- plotNeighborhoodSizeHist(small_milo, bins=100) -->

<!-- ``` -->


<!-- Make model matrix for testing. I use Age as an ordinal variable for testing. -->
<!-- ```{r} -->
<!-- th.meta <- data.frame(colData(small_milo)[,c("Sample","Age")])  -->
<!-- th.meta$Age <- ordered(th.meta$Age, levels=c('7w','17w')) -->
<!-- th.meta <- -->
<!--   distinct(th.meta) %>% -->
<!--   rownames_to_column() %>% -->
<!--   select(Sample, Age) %>% -->
<!--   column_to_rownames("Sample") -->

<!-- th.meta %>% -->
<!--   # filter(Age=="16w") -->
<!--   ggplot(aes(Age)) + geom_bar() -->

<!-- th.model <- model.matrix(~  Age, data=th.meta) -->
<!-- th.model -->
<!-- ``` -->


<!-- ```{r} -->
<!-- small_milo <- countCells(small_milo,  -->
<!--                    data = data.frame(colData(small_milo)[,c("Sample","Age")]), -->
<!--                    samples = "Sample") -->

<!-- ``` -->

<!-- ```{r} -->
<!-- graph_spatialFDR <- function(neighborhoods, graph, pvalues, connectivity='vertex', pca=NULL){ -->
<!--   # input a set of neighborhoods as a list of graph vertices -->
<!--   # the input graph and the unadjusted GLM p-values -->
<!--   #' neighborhoods: list of vertices and their respective neighborhoods -->
<!--   #' graph: input kNN graph -->
<!--   #' pvalues: a vector of pvalues in the same order as the neighborhood indices -->
<!--   #' connectivity: character - edge or vertex to calculate neighborhood connectivity or distance to use average Euclidean distance -->
<!--   #' pca: matrix of PCs to calculate Euclidean distances, only required when connectivity == distance -->
<!--   # Discarding NA pvalues. -->
<!--   haspval <- !is.na(pvalues) -->
<!--   if (!all(haspval)) { -->
<!--       coords <- coords[haspval, , drop=FALSE] -->
<!--       pvalues <- pvalues[haspval] -->
<!--   } -->

<!--   # define the subgraph for each neighborhood then calculate the vertex connectivity for each -->
<!--   # this latter computation is quite slow - can it be sped up? -->
<!--   subgraphs <- lapply(1:length(neighborhoods[haspval]), -->
<!--                          FUN=function(X) induced_subgraph(graph, neighborhoods[haspval][[X]])) -->
<!--   # now loop over these sub-graphs to calculate the connectivity - this seems a little slow... -->
<!--   if(connectivity == "vertex"){ -->
<!--     t.connect <- lapply(subgraphs, FUN=function(EG) vertex_connectivity(EG)) -->
<!--   } else if(connectivity == "edge"){ -->
<!--     t.connect <- lapply(subgraphs, FUN=function(EG) edge_connectivity(EG)) -->
<!--   } else if(connectivity == "distance"){ -->
<!--     if(!is.null(pca)){ -->
<!--       t.connect <- lapply(1:length(neighborhoods[haspval]), -->
<!--                         FUN=function(PG) { -->
<!--                           x.pcs <- pca[neighborhoods[haspval][[PG]], ] -->
<!--                           x.euclid <- as.matrix(dist(x.pcs)) -->
<!--                           x.distdens <- 1/mean(x.euclid[lower.tri(x.euclid, diag=FALSE)]) -->
<!--                         return(x.distdens)}) -->
<!--     } else{ -->
<!--       stop("A matrix of PCs is required to calculate distances")   -->
<!--     } -->
<!--   }else{ -->
<!--     stop("connectivity option not recognised - must be either edge, vertex or distance") -->
<!--   } -->

<!--   # use 1/connectivity as the weighting for the weighted BH adjustment from Cydar -->
<!--   w <- 1/unlist(t.connect) -->
<!--   w[is.infinite(w)] <- 0 -->

<!--   # Computing a density-weighted q-value. -->
<!--   o <- order(pvalues) -->
<!--   pvalues <- pvalues[o] -->
<!--   w <- w[o] -->
<!--   adjp <- numeric(length(o)) -->
<!--   adjp[o] <- rev(cummin(rev(sum(w)*pvalues/cumsum(w)))) -->
<!--   adjp <- pmin(adjp, 1) -->
<!--   if (!all(haspval)) { -->
<!--     refp <- rep(NA_real_, length(haspval)) -->
<!--     refp[haspval] <- adjp -->
<!--     adjp <- refp -->
<!--     } -->
<!--   return(adjp) -->
<!-- } -->

<!-- # testQLF <- function(graph, nh_counts, th.model, connectivity='edge', pca=NULL){ -->
<!-- nh_counts <- small_milo@neighbourhoodCounts -->

<!-- dge <- DGEList(nh_counts[, rownames(th.model)], lib.size=log(colSums(nh_counts))) -->
<!-- dge <- estimateDisp(dge, th.model) -->

<!-- fit <- glmQLFit(dge, th.model, robust=TRUE) -->
<!-- # sim2.contrast <- makeContrasts(ConditionA - ConditionB, levels=th.model) -->
<!-- #   sim2.res <- glmQLFTest(sim2.fit, contrast=sim2.contrast) -->
<!-- milo_res <- as.data.frame(topTags(glmQLFTest(fit, coef=1), sort.by='none', n=Inf)) -->
<!-- milo_res$Sig <- as.factor(as.numeric(milo_res$FDR <= 0.05)) -->
<!-- milo_res$Neighbourhood <- as.numeric(rownames(milo_res)) -->

<!-- sim2.spatialfdr <- graph_spatialFDR(neighborhoods=small_milo@neighbourhoods,  -->
<!--                                     graph=small_milo@graph[["graph"]], -->
<!--                                     connectivity="distance",  -->
<!--                                     pvalues=milo_res$PValue, -->
<!--                                     pca=reducedDim(milo,"MOFA") -->
<!--                                     ) -->
<!-- ``` -->
<!-- ```{r} -->
<!-- milo_res_df <- data.frame(Vertex=names(small_milo@neighbourhoods), -->
<!--                           p=milo_res$PValue,  -->
<!--                           adjp=sim2.spatialfdr,  -->
<!--                           logFC=milo_res$logFC,  -->
<!--                           adjp_fdr=milo_res$FDR,  -->
<!--                           Sig=milo_res$Sig -->
<!--                           ) -->


<!-- milo_res_df %>% -->
<!--   mutate(is_sig=ifelse(adjp < 0.1, TRUE, FALSE)) %>% -->
<!--   ggplot(aes(logFC, -log10(adjp), color=is_sig)) + -->
<!--   geom_point(size=0.1) -->
<!-- ``` -->



<!-- ```{r} -->
<!-- # colData(small_milo) <- colData(sce[,which(sce$Age %in% c('7w','17w'))]) -->
<!-- colData(small_milo)["Vertex"] <- as.character(V(graph(small_milo))) -->
<!-- coldata_df <- -->
<!--   SingleCellExperiment::colData(small_milo) %>% -->
<!--   as.data.frame() %>% -->
<!--   rownames_to_column() %>% -->
<!--   left_join(milo_res_df)  -->

<!-- coldata_df -->
<!-- # colData(small_milo)[which(small_milo$Vertex=="850"),] -->
<!-- #   milo_res_df %>% -->
<!-- #     filter(logFC > 0) %>% pull(Vertex) -->

<!-- # colnames(milo_res_df) %in% colnames(colData(small_milo)) -->
<!-- ``` -->

<!-- ```{r} -->
<!-- coldata_df <- bind_cols(coldata_df, data.frame(reducedDim(small_milo, 'UMAP')))  -->
<!-- ``` -->


<!-- ```{r} -->
<!-- # pl_df <- scater::plotReducedDim(small_milo,dimred="UMAP", colour_by = "logFC", )$data   -->

<!-- coldata_df %>% -->
<!--   arrange(- logFC) %>% -->
<!--   ggplot(aes(X1,X2)) +  -->
<!--   geom_point(size=0.2, color="grey", alpha=0.5) + -->
<!--   geom_point(data=. %>% filter(!is.na(logFC)), aes(color=logFC), size=1) + -->
<!--   # scale_color_gradient2(mid=0, high = "red", low="blue") + -->
<!--   scale_color_viridis_c(option="magma") + -->
<!--   theme_dimred() -->

<!-- coldata_df %>% -->
<!--   arrange(- log10(adjp)) %>% -->
<!--   ggplot(aes(X1,X2)) +  -->
<!--   geom_point(size=0.2, color="grey", alpha=0.5) + -->
<!--   geom_point(data=. %>% filter(!is.na(adjp)), aes(color=-log10(adjp))) + -->
<!--   scale_color_viridis_c() + -->
<!--   theme_dimred() -->

<!-- ``` -->

<!-- ```{r} -->
<!-- coldata_df %>% -->
<!--   ggplot(aes(X1, X2)) + -->
<!--   geom_point(aes(color=Age), size=0.5) -->
<!-- ``` -->

### Use Age as ordinal variable w all ages

```{r}
knn_graph <- buildKNNGraph(reducedDim(milo, "MOFA"), k=50, d=NA, transposed=TRUE)
miloR::graph(milo) <- knn_graph
```

Run umap
```{r}
umap_th <- uwot::umap(reducedDim(milo, "MOFA"), n_neighbors=50, verbose=TRUE)
reducedDim(milo, 'UMAP') <- umap_th
```

```{r, fig.width=10, fig.height=10}
scater::plotUMAP(milo, colour_by="Age", point_size=0.5, point_alpha=0.5) +
  facet_wrap('colour_by')
```

Sample neighborhoods with refined sampling scheme

```{r}
# milo@neighbourhoods <- list()
system.time(milo <- makeNeighbourhoods(milo, prop=0.1, k = 50, d=5, refined = TRUE, reduced_dims = "PCA", seed = 43))

plotNeighborhoodSizeHist(milo, bins=80)
```


Make model matrix for testing. I use Age as an ordinal variable for testing.
```{r}
th.meta <- data.frame(colData(milo)[,c("Sample","Age")]) 
th.meta$Age <- ordered(th.meta$Age, levels=c('7w', '8w', '9w', '10w', '11w', '12w', '13w', '14w', '16w', '17w'))
th.meta$Age <- as.numeric(th.meta$Age)
th.meta <-
  distinct(th.meta) %>%
  rownames_to_column() %>%
  select(Sample, Age) %>%
  column_to_rownames("Sample")

th.meta %>%
  # filter(Age=="16w")
  ggplot(aes(Age)) + geom_bar()

th.model <- model.matrix(~  Age, data=th.meta)
th.model
```


```{r}
milo <- countCells(milo, 
                   data = data.frame(colData(milo)[,c("Sample","Age")]),
                   samples = "Sample")


```

```{r}
nh_counts <- milo@neighbourhoodCounts

milo_res <- testNeighbourhoods(milo, design = ~ Age, data = th.meta)
hist(milo_res$PValue)
```

```{r}
milo_res %>%
  ggplot(aes(PValue, SpatialFDR)) + geom_point() +
  geom_abline(linetype=2) 

milo_res %>%
  ggplot(aes(SpatialFDR)) + geom_histogram()

milo_res %>%
  mutate(is_sig=ifelse(SpatialFDR < 0.05, TRUE, FALSE)) %>%
  ggplot(aes(logFC, -log10(SpatialFDR), color=is_sig)) +
  geom_point(alpha=0.2)
```

```{r}
plotMiloReducedDim(milo, milo_results = milo_res, filter_alpha = NULL)
plotMiloReducedDim(milo, milo_results = milo_res, filter_alpha = 0.1) 
```

```{r, fig.height=8, fig.width=8}
plotMiloReducedDim(milo, milo_results = milo_res, split_by = "cell types", filter_alpha = 0.1)
```

Perhaps the most interesting part is that proliferative double positive T cells seem to be divided in 2 groups, those more enriched in early stages and late stages. What are the biological differences between these?

```{r}
celltype.df <- data.frame(nhIndex=1:ncol(milo), cell.types=colData(milo)[,"cell types"],
                          CD3=counts(milo)["CD3D",], CD28=counts(milo)["CD28",], CD4=counts(milo)["CD4",],
                          CD8A=counts(milo)["CD8A",], CD8B=counts(milo)["CD8B",])



milo_res %>% 
  mutate(nhIndex = unlist(neighbourhoodIndex(milo))) %>%
  left_join(pivot_longer(celltype.df, cols=- c(nhIndex, cell.types), names_to = "gene", values_to = "counts") , by="nhIndex") %>%
  # group_by(gene) %>%
  # mutate(zscore = scale(log1p(counts))) %>%
  filter(cell.types=="DP(P)") %>%
  filter(SpatialFDR < 0.1) %>%
  mutate(group=ifelse(logFC > 0, "late", "early")) %>%
  arrange(counts) %>%
  # filter(gene=="CD8A") %>%
  ggplot(aes(group, counts)) +
  geom_violin(scale="width") +
  geom_jitter(size=0.1, width=0.1) +
  facet_wrap(gene~., scales="free_y") +
  scale_color_viridis_c()

  
```
```{r}
df <- plotMiloReducedDim(milo, milo_results = milo_res, split_by = "cell types", filter_alpha = 0.1)$data
df %>% 
  filter(split_by=="DP(P)") %>%
  ggplot(aes(X,Y)) + geom_point() 

dpp_milo <- milo[,which(milo$`cell types`=="DP(P)")]

scater::plotUMAP(dpp_milo, colour_by=c("CD3D"))
```

<!-- Compare log-FC and proportions -->

<!-- ```{r} -->
<!-- celltype.df <- data.frame(nhIndex=1:ncol(milo), cell.types=colData(milo)[,"cell types"], -->
<!--                           Age=colData(milo)[,"Age"]) -->
<!-- left_join(celltype.df, mutate(milo_res, nhIndex = unlist(neighbourhoodIndex(milo))), by="nhIndex")  %>% -->
<!--   group_by(Age) %>% -->
<!--   mutate(tot_age=n()) %>% -->
<!--   ungroup() %>% -->
<!--   group_by(cell.types, Age) %>% -->
<!--   summarise(mean_logFC = mean(logFC, na.rm=T), sd_logFC = sd(logFC, na.rm=T), perc_age=n()/tot_age) %>% -->
<!--   ggplot(aes(Age, mean_logFC, color=Age)) +  -->
<!--   geom_point() + -->
<!--   # geom_errorbar(aes(ymin=mean_logFC-sd_logFC, ymax=mean_logFC + sd_logFC), width=0.3) + -->
<!--   facet_wrap(cell.types~., scales="free_y") -->

<!-- left_join(celltype.df, mutate(milo_res, nhIndex = unlist(neighbourhoodIndex(milo))), by="nhIndex")  %>% -->
<!--   group_by(Age) %>% -->
<!--   mutate(tot_age=n()) %>% -->
<!--   ungroup() %>% -->
<!--   group_by(cell.types, Age) %>% -->
<!--   summarise(mean_logFC = mean(logFC, na.rm=T), sd_logFC = sd(logFC, na.rm=T), perc_age=n()/tot_age) %>% -->
<!--   ggplot(aes(Age, perc_age, color=Age)) +  -->
<!--   geom_point() + -->
<!--   # geom_errorbar(aes(ymin=mean_logFC-sd_logFC, ymax=mean_logFC + sd_logFC), width=0.3) + -->
<!--   facet_wrap(cell.types~., scales="free_y") -->
<!-- ``` -->


## Compare enrichment and pseudotime ordering
```{r}

```



<!-- ## Filtering just Agex for which you have > 2 samples -->


<!-- ```{r} -->
<!-- th.meta <- data.frame(colData(sce)[,c("Sample","Age")])  -->
<!-- keep.ages <- c('11w','12w','13w','14w','16w','17w') -->

<!-- th.meta$Age <- ordered(th.meta$Age, levels=c('7w','8w','9w','10w','11w','12w','13w','14w','16w','17w')) -->
<!-- th.meta <- -->
<!--   distinct(th.meta) %>% -->
<!--   filter(Age %in% keep.ages) %>% -->
<!--   mutate(Age = ordered(Age, levels=keep.ages)) %>% -->
<!--   rownames_to_column() %>% -->
<!--   select(Sample, Age) %>% -->
<!--   column_to_rownames("Sample") -->

<!-- th.meta %>% -->
<!--   ggplot(aes(Age)) + geom_bar() -->

<!-- th.model <- model.matrix(~  Age, data=th.meta) -->
<!-- th.model -->

<!-- ``` -->


<!-- ```{r} -->
<!-- # milo_filt <- milo[,which(milo$Age %in% keep.ages)] -->

<!-- milo <- countCells(milo,  -->
<!--                    data = data.frame(colData(milo)[,c("Sample","Age")]), -->
<!--                    samples = "Sample") -->


<!-- milo@neighbourhoodCounts -->
<!-- ``` -->

<!-- ```{r} -->
<!-- graph_spatialFDR <- function(neighborhoods, graph, pvalues, connectivity='vertex', pca=NULL){ -->
<!--   # input a set of neighborhoods as a list of graph vertices -->
<!--   # the input graph and the unadjusted GLM p-values -->
<!--   #' neighborhoods: list of vertices and their respective neighborhoods -->
<!--   #' graph: input kNN graph -->
<!--   #' pvalues: a vector of pvalues in the same order as the neighborhood indices -->
<!--   #' connectivity: character - edge or vertex to calculate neighborhood connectivity or distance to use average Euclidean distance -->
<!--   #' pca: matrix of PCs to calculate Euclidean distances, only required when connectivity == distance -->
<!--   # Discarding NA pvalues. -->
<!--   haspval <- !is.na(pvalues) -->
<!--   if (!all(haspval)) { -->
<!--       coords <- coords[haspval, , drop=FALSE] -->
<!--       pvalues <- pvalues[haspval] -->
<!--   } -->

<!--   # define the subgraph for each neighborhood then calculate the vertex connectivity for each -->
<!--   # this latter computation is quite slow - can it be sped up? -->
<!--   subgraphs <- lapply(1:length(neighborhoods[haspval]), -->
<!--                          FUN=function(X) induced_subgraph(graph, neighborhoods[haspval][[X]])) -->
<!--   # now loop over these sub-graphs to calculate the connectivity - this seems a little slow... -->
<!--   if(connectivity == "vertex"){ -->
<!--     t.connect <- lapply(subgraphs, FUN=function(EG) vertex_connectivity(EG)) -->
<!--   } else if(connectivity == "edge"){ -->
<!--     t.connect <- lapply(subgraphs, FUN=function(EG) edge_connectivity(EG)) -->
<!--   } else if(connectivity == "distance"){ -->
<!--     if(!is.null(pca)){ -->
<!--       t.connect <- lapply(1:length(neighborhoods[haspval]), -->
<!--                         FUN=function(PG) { -->
<!--                           x.pcs <- pca[neighborhoods[haspval][[PG]], ] -->
<!--                           x.euclid <- as.matrix(dist(x.pcs)) -->
<!--                           x.distdens <- 1/mean(x.euclid[lower.tri(x.euclid, diag=FALSE)]) -->
<!--                         return(x.distdens)}) -->
<!--     } else{ -->
<!--       stop("A matrix of PCs is required to calculate distances")   -->
<!--     } -->
<!--   }else{ -->
<!--     stop("connectivity option not recognised - must be either edge, vertex or distance") -->
<!--   } -->

<!--   # use 1/connectivity as the weighting for the weighted BH adjustment from Cydar -->
<!--   w <- 1/unlist(t.connect) -->
<!--   w[is.infinite(w)] <- 0 -->

<!--   # Computing a density-weighted q-value. -->
<!--   o <- order(pvalues) -->
<!--   pvalues <- pvalues[o] -->
<!--   w <- w[o] -->
<!--   adjp <- numeric(length(o)) -->
<!--   adjp[o] <- rev(cummin(rev(sum(w)*pvalues/cumsum(w)))) -->
<!--   adjp <- pmin(adjp, 1) -->
<!--   if (!all(haspval)) { -->
<!--     refp <- rep(NA_real_, length(haspval)) -->
<!--     refp[haspval] <- adjp -->
<!--     adjp <- refp -->
<!--     } -->
<!--   return(adjp) -->
<!-- } -->

<!-- # testQLF <- function(graph, nh_counts, th.model, connectivity='edge', pca=NULL){ -->
<!-- nh_counts <- milo@neighbourhoodCounts -->

<!-- dge <- DGEList(nh_counts[, rownames(th.model)], lib.size=log(colSums(nh_counts))) -->
<!-- dge <- estimateDisp(dge, th.model) -->

<!-- fit <- glmQLFit(dge, th.model, robust=TRUE) -->
<!-- # sim2.contrast <- makeContrasts(ConditionA - ConditionB, levels=th.model) -->
<!-- #   sim2.res <- glmQLFTest(sim2.fit, contrast=sim2.contrast) -->
<!-- milo_res <- as.data.frame(topTags(glmQLFTest(fit, coef=1), sort.by='none', n=Inf)) -->
<!-- milo_res$Sig <- as.factor(as.numeric(milo_res$FDR <= 0.05)) -->
<!-- milo_res$Neighbourhood <- as.numeric(rownames(milo_res)) -->

<!-- sim2.spatialfdr <- graph_spatialFDR(neighborhoods=milo@neighbourhoods,  -->
<!--                                     graph=milo@graph[["graph"]], -->
<!--                                     connectivity="distance",  -->
<!--                                     pvalues=milo_res$PValue, -->
<!--                                     pca=reducedDim(milo,"MOFA") -->
<!--                                     ) -->

<!-- ``` -->


<!-- ## Picking k parameter -->

<!-- ```{r} -->
<!-- test_mean_nh_size <- function(m, prop, k, n_cells, d=30){ -->
<!--   m <- m[,sample(colnames(m), size = n_cells)] -->
<!--   m <- buildGraph(m, k = k, d = d) -->
<!--   refined_nh <- neighbourhoods(makeNeighbourhoods(m, prop=prop, k=k, d=d, refined = TRUE, seed=42)) -->
<!--   return(mean(sapply(refined_nh, length))) -->
<!-- } -->

<!-- k_vec <- seq(10,50, by=5) -->
<!-- # ncells_vec <- round(ncol(milo)*seq(0.1,1, by=0.1),0) -->

<!-- grid_df <- expand.grid(ncells_vec, k_vec) -->
<!-- colnames(grid_df) <- c("n_cells", "k") -->
<!-- mean_nh_sizes_th <- apply(grid_df, 1, function(x) test_mean_nh_size(milo, prop = 0.2, x["k"], x["n_cells"], d=5)) -->

<!-- test_mean_nh_size(milo, prop = 0.2, grid_df[1,"k"], grid_df[1,"n_cells"], d=5) -->
<!-- ``` -->



